package MyArray;

import java.util.Arrays;

//定义一个ArrayList  实现接口 写方法
public class MyArrayList implements List{

    private int usedSize;
    private int initial=10;

    private int[] Array = new int[initial];

    private void grow(){
        initial*=2;
        // 对于数组的扩容我们采用 copyOf方法
        Array = Arrays.copyOf(Array,initial);
    }

    @Override
    public void add(int data) {
        if(IsEmpty()){
            grow();
        }
        Array[usedSize]  = data;
        usedSize++;
    }

    private void IsIllegal(int pos){
        if(pos<0||pos>usedSize) {
            // 在数据结构中插入的位置的前驱不能为 0
            throw new IndexIllegal("pos位置不合法");
        }
    }

    private boolean IsEmpty(){
        return usedSize == 0;
    }
    @Override
    public void add(int pos, int data) {
    // 插入我们首先要判断下标是否合理
        try{
            IsIllegal(pos);
            // 在判断是否为满  满就扩容
            if(IsEmpty()){
               grow();
            }
            //添加 从后往前
            for(int i = usedSize-1;i>=pos;i--){
                Array[i+1] = Array[i];
            }
            Array[pos] = data;
            usedSize++;
        }catch(IndexIllegal e){
            e.printStackTrace();
        }
    }

    @Override
    public boolean contains(int toFind) {
        for(int i = 0;i<usedSize;i++){
            if(Array[i] == toFind)
                return true;
        }
        return false;
    }

    @Override
    public int indexOf(int toFind) {
        for(int i = 0;i<usedSize;i++){
            if(Array[i] == toFind)
                return i;
        }
        return -1;
    }

    private void IsNull(int pos ){
       if(usedSize==0){
           throw new CheckNull("数组为Null");
       }
    }
    @Override
    public int get(int pos) {
        //检查是否为空
        // 检查位置是否合法
        try{
            IsNull(pos);
            IsIllegal(pos);
            return Array[pos];
        }catch(CheckNull e){
            e.printStackTrace();
        }catch (IndexIllegal e){
            e.printStackTrace();
        }
        //没获取到就是-1
       return -1;
    }

    @Override
    public void set(int pos, int value) {
        try{
            IsNull(pos);
            IsIllegal(pos);
            Array[pos] = value;
        }catch(CheckNull e){
            e.printStackTrace();
        }catch (IndexIllegal e){
            e.printStackTrace();
        }
    }

    @Override
    public void remove(int toRemove) {
        try{
            if(IsEmpty()){
                throw new CheckNull("数组为空");
            }
            boolean flg = false;
            int pos;
            for( pos = 0;pos<usedSize;pos++){
                if(Array[pos]==toRemove){
                    flg = true;
                    break;
                }
            }
            if(flg){
                for(int i = pos ;i<usedSize-1;i++){
                    Array[i] = Array[i+1];
                }
                usedSize--;
            }
            else {
                System.out.println("不存在");
            }
        }catch (CheckNull e){
            e.printStackTrace();
        }

    }

    @Override
    public int size() {
        return usedSize;
    }

    @Override
    public void clear() {
        //  我们这个Array是一个基本数据类型的 可以直接new 一个新的 数组
        //但去过是 引用数据类型 必须遍历 置为NUll 否则会造成内存泄露
//        Array = new int[initial];
        usedSize = 0;
    }
    public void display(){
        for(int i =0;i<usedSize;i++)
            System.out.print(Array[i]+" ");
        System.out.println();
    }
}
